import re
import time
from .base_finance_query import BaseFinanceQuery
# 从core.logger导入get_logger函数
from ..core.logger import get_logger

# 使用get_logger函数初始化logger
logger = get_logger('agent.investor_queries')


class InvestorQueries(BaseFinanceQuery):
    """
    投资者相关查询处理类
    处理所有与投资者相关的复杂查询
    """
    
    def __init__(self):
        super().__init__()
    
    def calculate_percentage_of_funds_with_more_individual_shares(self, query: str) -> str:
        """
        计算个人投资者持有份额超过机构投资者的基金比例
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果，包括百分比
        """
        start_time = time.time()
        logger.info("开始计算个人投资者持有份额超过机构投资者的基金比例")
        try:
            # 提取基金管理公司
            # 改进的正则表达式，更准确地匹配基金公司名称
            fund_company_match = re.search(r'在\d{4}年的.*?报告里，(.*?)管理的基金', query)
            if not fund_company_match:
                fund_company_match = re.search(r'(?:报告里，)?(.*?)管理的基金', query)
                
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                logger.info(f"提取的原始基金公司名称: '{fund_company}'")
                
                # 处理常见的开头指令性词语
                for prefix in ['请列出', '列出', '查询', '找出', '报告里']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
                
                # 特殊处理：金鹰基金管理有限公司在数据库中可能以不同形式存在
                if '金鹰基金' in fund_company:
                    logger.info(f"检测到金鹰基金管理公司，将查询关键词从 '{fund_company}' 调整为 '金鹰基金管理有限公司'")
                    fund_company = '金鹰基金管理有限公司'
                
                # 特殊处理：浙江浙商证券资产管理有限公司的基金在数据库中使用'浙商汇金'作为标识
                if '浙商证券资产管理' in fund_company:
                    logger.info(f"检测到浙商证券资产管理公司，将查询关键词从 '{fund_company}' 调整为 '浙商汇金'")
                    fund_company = '浙商汇金'
                
                logger.info(f"最终使用的查询关键词: '{fund_company}'")
            else:
                logger.error("无法从查询中提取基金管理公司信息")
                return "无法从查询中提取基金管理公司信息"
            
            # 提取报告期和年份
            report_period = None
            report_period_match = re.search(r'(中期报告|年度报告)', query)
            if report_period_match:
                report_period = report_period_match.group(1)
            
            report_year = None
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                report_year = year_match.group(1)
            
            logger.info("查询条件: 基金管理公司='{}', 报告类型='{}', 年份='{}'".format(
                fund_company, report_period, report_year))
            
            def _query(cursor, fund_company, report_period, report_year):
                # 查询个人投资者持有份额超过机构投资者的基金数量
                if report_period and report_year:
                    # 如果指定了报告期和年份，则在查询中加入报告期和年份条件
                    count_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.报告类型 LIKE ?
                        AND b.定期报告所属年度 = ?
                        AND CAST(b.个人投资者持有的基金份额 AS REAL) > 
                            CAST(b.机构投资者持有的基金份额 AS REAL)
                    """
                    logger.info("执行SQL查询个人投资者份额超过机构投资者的基金数量")
                    logger.info("SQL语句: {}".format(count_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%', 报告类型 LIKE '{}', 年度='{}'".format(
                        fund_company, report_period, report_year))
                    cursor.execute(count_query, (f"%{fund_company}%", report_period, report_year))
                elif report_year:
                    # 如果只指定了年份
                    count_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.定期报告所属年度 = ?
                        AND CAST(b.个人投资者持有的基金份额 AS REAL) > 
                            CAST(b.机构投资者持有的基金份额 AS REAL)
                    """
                    logger.info("执行SQL查询个人投资者份额超过机构投资者的基金数量")
                    logger.info("SQL语句: {}".format(count_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%', 年度='{}'".format(
                        fund_company, report_year))
                    cursor.execute(count_query, (f"%{fund_company}%", report_year))
                else:
                    # 如果没有指定报告期和年份
                    count_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND CAST(b.个人投资者持有的基金份额 AS REAL) > 
                            CAST(b.机构投资者持有的基金份额 AS REAL)
                    """
                    logger.info("执行SQL查询个人投资者份额超过机构投资者的基金数量")
                    logger.info("SQL语句: {}".format(count_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%'".format(fund_company))
                    cursor.execute(count_query, (f"%{fund_company}%",))
                
                individual_more_result = cursor.fetchone()
                individual_more_count = individual_more_result['count'] if individual_more_result and individual_more_result['count'] is not None else 0
                logger.debug("个人投资者份额超过机构投资者的基金数量: {}".format(individual_more_count))
                
                # 查询基金管理的基金总数
                if report_period and report_year:
                    total_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.报告类型 LIKE ?
                        AND b.定期报告所属年度 = ?
                    """
                    logger.info("执行SQL查询基金总数")
                    logger.info("SQL语句: {}".format(total_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%', 报告类型 LIKE '{}', 年度='{}'".format(
                        fund_company, report_period, report_year))
                    cursor.execute(total_query, (f"%{fund_company}%", report_period, report_year))
                elif report_year:
                    total_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.定期报告所属年度 = ?
                    """
                    logger.info("执行SQL查询基金总数")
                    logger.info("SQL语句: {}".format(total_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%', 年度='{}'".format(
                        fund_company, report_year))
                    cursor.execute(total_query, (f"%{fund_company}%", report_year))
                else:
                    total_query = """
                        SELECT COUNT(DISTINCT a.基金代码) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ?
                    """
                    logger.info("执行SQL查询基金总数")
                    logger.info("SQL语句: {}".format(total_query))
                    logger.info("查询参数: 管理人 LIKE '%{}%'".format(fund_company))
                    cursor.execute(total_query, (f"%{fund_company}%",))
                
                total_result = cursor.fetchone()
                total_count = total_result['count'] if total_result and total_result['count'] is not None else 0
                logger.debug("符合条件的基金总数: {}".format(total_count))
                
                return individual_more_count, total_count
            
            individual_more_count, total_count = self._execute_query_with_db(_query, fund_company, report_period, report_year)
            
            if total_count > 0:
                percentage = (individual_more_count / total_count) * 100
                logger.info("查询成功完成，个人投资者持有份额超过机构投资者的基金数量: {}，总基金数: {}".format(
                    individual_more_count, total_count))
                
                period_text = ""
                if report_period and report_year:
                    if "中期报告" in report_period:
                        period_text = f"在{report_year}年中期报告里"
                    elif "年度报告" in report_period:
                        period_text = f"在{report_year}年年度报告里"
                elif report_period:
                    if "中期报告" in report_period:
                        period_text = "在中期报告里"
                    elif "年度报告" in report_period:
                        period_text = "在年度报告里"
                elif report_year:
                    period_text = f"在{report_year}年"
                else:
                    period_text = "在报告里"
                    
                result = f"{period_text}，{fund_company}管理的基金中，有{percentage:.2f}%的基金是个人投资者持有的份额超过机构投资者"
                logger.info(f"计算结果: {result}")
                return result
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}管理的基金数据"
            
        except Exception as e:
            logger.error(f"计算个人投资者持有份额超过机构投资者的基金比例时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            exec_time = time.time() - start_time
            logger.info(f"计算个人投资者持有份额超过机构投资者的基金比例完成，耗时: {exec_time:.4f}秒")

    def count_funds_with_institutional_share_over_personal(self, query: str) -> str:
        """
        统计基金中机构投资者持有份额比个人投资者多的基金数量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info("开始统计机构投资者持有份额比个人投资者多的基金数量")
        
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)管理的基金', query)
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
            else:
                return "无法从查询中提取基金管理公司信息"
            
            # 提取报告期和年份
            report_period = None
            report_period_match = re.search(r'(中期报告|年度报告)', query)
            if report_period_match:
                report_period = report_period_match.group(1)
            
            report_year = None
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                report_year = year_match.group(1)
            
            logger.info("查询条件: 基金管理公司='{}', 报告类型='{}', 年份='{}'".format(
                fund_company, report_period, report_year))
            
            def _query(cursor, fund_company, report_period, report_year):
                # 查询机构投资者持有份额比个人投资者多的基金数量
                if report_period and report_year:
                    # 如果指定了报告期和年份，则在查询中加入报告期和年份条件
                    count_query = """
                        SELECT COUNT(*) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.报告类型 LIKE ?
                        AND b.定期报告所属年度 = ?
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 
                            CAST(REPLACE(b.个人投资者持有的基金份额占总份额比例, '%', '') AS REAL)
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%', 报告类型 LIKE '{}', 年度='{}'".format(
                        fund_company, report_period, report_year))
                    cursor.execute(count_query, (f"%{fund_company}%", report_period, report_year))
                elif report_year:
                    # 如果只指定了年份
                    count_query = """
                        SELECT COUNT(*) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.定期报告所属年度 = ?
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 
                            CAST(REPLACE(b.个人投资者持有的基金份额占总份额比例, '%', '') AS REAL)
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%', 年度='{}'".format(
                        fund_company, report_year))
                    cursor.execute(count_query, (f"%{fund_company}%", report_year))
                else:
                    # 如果没有指定报告期和年份
                    count_query = """
                        SELECT COUNT(*) as count
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 
                            CAST(REPLACE(b.个人投资者持有的基金份额占总份额比例, '%', '') AS REAL)
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%'".format(fund_company))
                    cursor.execute(count_query, (f"%{fund_company}%",))
                
                result = cursor.fetchone()
                return result['count'] if result and result['count'] is not None else 0
            
            count = self._execute_query_with_db(_query, fund_company, report_period, report_year)
            
            if count > 0:
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                
                period_text = ""
                if report_period and report_year:
                    if "中期报告" in report_period:
                        period_text = f"在{report_year}年中期报告中"
                    elif "年度报告" in report_period:
                        period_text = f"在{report_year}年年度报告中"
                elif report_period:
                    if "中期报告" in report_period:
                        period_text = "在中期报告中"
                    elif "年度报告" in report_period:
                        period_text = "在年度报告中"
                elif report_year:
                    period_text = f"在{report_year}年"
                else:
                    period_text = "在报告中"
                
                return f"{period_text}，{fund_company}管理的基金中，机构投资者持有份额比个人投资者多的基金数量为{count}只"
            else:
                logger.warning("查询未返回有效结果")
                return f"未找到{fund_company}管理的机构投资者持有份额比个人投资者多的基金数据"
            
        except Exception as e:
            logger.error(f"统计机构投资者持有份额比个人投资者多的基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            exec_time = time.time() - start_time
            logger.info(f"统计机构投资者持有份额比个人投资者多的基金数量完成，耗时: {exec_time:.4f}秒")

    def count_funds_with_institutional_share_over_50(self, query: str) -> str:
        """
        统计机构投资者持有份额占比超过50%的基金数量及总持有量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info("开始统计机构投资者持有份额占比超过50%的基金数量及总持有量")
        
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)管理的基金', query)
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
            else:
                return "无法从查询中提取基金管理公司信息"
            
            # 提取报告期和年份
            report_period = None
            report_period_match = re.search(r'(中期报告|年度报告)', query)
            if report_period_match:
                report_period = report_period_match.group(1)
            
            report_year = None
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                report_year = year_match.group(1)
            
            logger.info("查询条件: 基金管理公司='{}', 报告类型='{}', 年份='{}'".format(
                fund_company, report_period, report_year))
            
            def _query(cursor, fund_company, report_period, report_year):
                # 查询机构投资者持有份额占比超过50%的基金数量及总持有量
                if report_period and report_year:
                    # 如果指定了报告期和年份，则在查询中加入报告期和年份条件
                    sql_query = """
                        SELECT COUNT(*) as count, SUM(CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL)) as total_holding
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.报告类型 LIKE ?
                        AND b.定期报告所属年度 = ?
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 50
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%', 报告类型 LIKE '{}', 年度='{}'".format(
                        fund_company, report_period, report_year))
                    cursor.execute(sql_query, (f"%{fund_company}%", report_period, report_year))
                elif report_year:
                    # 如果只指定了年份
                    sql_query = """
                        SELECT COUNT(*) as count, SUM(CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL)) as total_holding
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND b.定期报告所属年度 = ?
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 50
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%', 年度='{}'".format(
                        fund_company, report_year))
                    cursor.execute(sql_query, (f"%{fund_company}%", report_year))
                else:
                    # 如果没有指定报告期和年份
                    sql_query = """
                        SELECT COUNT(*) as count, SUM(CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL)) as total_holding
                        FROM 基金基本信息 a
                        JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                        WHERE a.管理人 LIKE ? 
                        AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 50
                    """
                    logger.info("执行SQL查询")
                    logger.info("查询参数: 管理人 LIKE '%{}%'".format(fund_company))
                    cursor.execute(sql_query, (f"%{fund_company}%",))
                
                result = cursor.fetchone()
                return result
            
            result = self._execute_query_with_db(_query, fund_company, report_period, report_year)
            
            if result:
                count = result['count']
                total_holding = result['total_holding'] if result['total_holding'] is not None else 0
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                
                # 格式化总持有量（保留两位小数）
                formatted_total_holding = "{:.2f}".format(total_holding)
                
                period_text = ""
                if report_period and report_year:
                    if "中期报告" in report_period:
                        period_text = f"在{report_year}年中期报告中"
                    elif "年度报告" in report_period:
                        period_text = f"在{report_year}年年度报告中"
                elif report_period:
                    if "中期报告" in report_period:
                        period_text = "在中期报告中"
                    elif "年度报告" in report_period:
                        period_text = "在年度报告中"
                elif report_year:
                    period_text = f"在{report_year}年"
                
                return f"{period_text}，{fund_company}管理的基金中，机构投资者持有份额占比超过50%的基金有{count}只，他们总共持有了{formatted_total_holding}%"
            else:
                logger.warning("查询未返回有效结果")
                return "未找到机构投资者持有份额占比超过50%的基金数据"
            
        except Exception as e:
            logger.error(f"统计机构投资者持有份额占比超过50%的基金数量及总持有量时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            exec_time = time.time() - start_time
            logger.info(f"统计机构投资者持有份额占比超过50%的基金数量及总持有量完成，耗时: {exec_time:.4f}秒")

    def _extract_fund_company_from_query(self, query: str) -> str:
        """
        从查询中提取基金管理公司
        
        Args:
            query: 查询字符串
            
        Returns:
            基金管理公司名称
        """
        # 提取基金管理公司
        fund_company_match = re.search(r'(.*?)管理的基金', query)
        if fund_company_match:
            fund_company = fund_company_match.group(1).strip()
            # 处理常见的开头指令性词语
            for prefix in ['请计算', '计算', '查询', '我想知道']:
                if fund_company.startswith(prefix):
                    fund_company = fund_company[len(prefix):].strip()
                    break
            return fund_company
        return ""

    def handle_holder_count_comparison(self, query: str) -> str:
        """
        处理基金持有人数量比较查询
        
        Args:
            query: 查询文本
            
        Returns:
            查询结果
        """
        try:
            # 提取比较值
            value_match = re.search(r'(\d+(?:\.\d+)?)万', query)
            if not value_match:
                return ""
            
            target_value = float(value_match.group(1))
            
            if "高于" in query:
                sql_query = """
                    SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                    FROM 基金持有人结构表 
                    WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                    AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                    AND [机构投资者持有份额占基金总份额比] > 0
                    AND [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] > ?
                    ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] DESC
                    LIMIT 10
                """
                comparison = "高于"
            else:
                sql_query = """
                    SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                    FROM 基金持有人结构表 
                    WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                    AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                    AND [机构投资者持有份额占基金总份额比] > 0
                    AND [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] < ?
                    ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] DESC
                    LIMIT 10
                """
                comparison = "低于"
            
            result = self._execute_query(sql_query, (target_value*10000,))
            if result:
                result_lines = [f"基金持有人数量{comparison}{target_value}万的基金有:"]
                for row in result:
                    holders_count = row['holders'] if row['holders'] else 0
                    result_lines.append(f"  {row['基金代码']}: 约{holders_count/10000:.2f}万人")
                return "\n".join(result_lines)
            return ""
        except Exception as e:
            logger.error(f"处理基金持有人数量比较查询出错: {e}")
            return ""